/*******************************************************************************
* Copyright (c) 2000, 2016 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.ui.internal;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.SortedSet;
import java.util.TreeSet;
import org.eclipse.core.commands.common.EventManager;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IExtension;
import org.eclipse.core.runtime.IExtensionPoint;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.ISafeRunnable;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.SafeRunner;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.dynamichelpers.ExtensionTracker;
import org.eclipse.core.runtime.dynamichelpers.IExtensionChangeHandler;
import org.eclipse.core.runtime.dynamichelpers.IExtensionTracker;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.jface.util.PropertyChangeEvent;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.IElementFactory;
import org.eclipse.ui.IMemento;
import org.eclipse.ui.IPersistableElement;
import org.eclipse.ui.IWorkbenchPreferenceConstants;
import org.eclipse.ui.IWorkingSet;
import org.eclipse.ui.IWorkingSetElementAdapter;
import org.eclipse.ui.IWorkingSetManager;
import org.eclipse.ui.IWorkingSetUpdater;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.XMLMemento;
import org.eclipse.ui.dialogs.IWorkingSetEditWizard;
import org.eclipse.ui.dialogs.IWorkingSetNewWizard;
import org.eclipse.ui.dialogs.IWorkingSetPage;
import org.eclipse.ui.dialogs.IWorkingSetSelectionDialog;
import org.eclipse.ui.internal.dialogs.WorkingSetEditWizard;
import org.eclipse.ui.internal.dialogs.WorkingSetNewWizard;
import org.eclipse.ui.internal.dialogs.WorkingSetSelectionDialog;
import org.eclipse.ui.internal.misc.StatusUtil;
import org.eclipse.ui.internal.registry.IWorkbenchRegistryConstants;
import org.eclipse.ui.internal.registry.WorkingSetDescriptor;
import org.eclipse.ui.internal.registry.WorkingSetRegistry;
import org.eclipse.ui.internal.util.PrefUtil;
import org.eclipse.ui.progress.WorkbenchJob;
import org.eclipse.ui.statushandlers.StatusManager;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleContext;
import org.osgi.framework.BundleEvent;
import org.osgi.framework.BundleListener;
/**
* Abstract implementation of <code>IWorkingSetManager</code>.
*/
public abstract class AbstractWorkingSetManager extends EventManager implements
IWorkingSetManager, BundleListener, IExtensionChangeHandler {
static abstract class WorkingSetRunnable implements ISafeRunnable {
@Override
public void handleException(Throwable exception) {
StatusManager.getManager().handle(
StatusUtil.newStatus(PlatformUI.PLUGIN_ID, exception));
}
}
private SortedSet<AbstractWorkingSet> workingSets = new TreeSet<>((o1, o2) -> o1.getUniqueId().compareTo(o2.getUniqueId()));
private List<IWorkingSet> recentWorkingSets = new ArrayList<>();
private BundleContext bundleContext;
private Map<String, IWorkingSetUpdater> updaters = new HashMap<>();
private Map<String, IWorkingSetElementAdapter> elementAdapters = new HashMap<>();
private static final IWorkingSetUpdater NULL_UPDATER = new IWorkingSetUpdater() {
@Override
public void add(IWorkingSet workingSet) {
}
@Override
public boolean remove(IWorkingSet workingSet) {
return true;
}
@Override
public boolean contains(IWorkingSet workingSet) {
return true;
}
@Override
public void dispose() {
}
};
private static final IWorkingSetElementAdapter IDENTITY_ADAPTER = new IWorkingSetElementAdapter() {
@Override
public IAdaptable[] adaptElements(IWorkingSet ws, IAdaptable[] elements) {
return elements;
}
@Override
public void dispose() {
}
};
/**
* Returns the descriptors for the given editable working set ids. If an id
* refers to a missing descriptor, or one that is non-editable, it is
* skipped. If <code>null</code> is passed, all editable descriptors are
* returned.
*
* @param supportedWorkingSetIds
* the ids for the working set descriptors, or <code>null</code>
* for all editable descriptors
* @return the descriptors corresponding to the given editable working set
* ids
*/
private static WorkingSetDescriptor[] getSupportedEditableDescriptors(String[] supportedWorkingSetIds) {
WorkingSetRegistry registry = WorkbenchPlugin.getDefault().getWorkingSetRegistry();
if (supportedWorkingSetIds == null) {
return registry.getNewPageWorkingSetDescriptors();
}
List<WorkingSetDescriptor> result = new ArrayList<>(supportedWorkingSetIds.length);
for (String supportedWorkingSetId : supportedWorkingSetIds) {
WorkingSetDescriptor desc = registry.getWorkingSetDescriptor(supportedWorkingSetId);
if (desc != null && desc.isEditable()) {
result.add(desc);
}
}
return result.toArray(new WorkingSetDescriptor[result.size()]);
}
protected AbstractWorkingSetManager(BundleContext context) {
bundleContext= context;
bundleContext.addBundleListener(this);
PlatformUI.getWorkbench().getExtensionTracker().registerHandler(this, ExtensionTracker
.createExtensionPointFilter(getExtensionPointFilter()));
}
/**
* Returns the working sets extension point.
*
* @return the working sets extension point
* @since 3.3
*/
private IExtensionPoint getExtensionPointFilter() {
return Platform.getExtensionRegistry().getExtensionPoint(
PlatformUI.PLUGIN_ID,
IWorkbenchRegistryConstants.PL_WORKINGSETS);
}
@Override
public void dispose() {
bundleContext.removeBundleListener(this);
for (IWorkingSetUpdater next : updaters.values()) {
SafeRunner.run(new WorkingSetRunnable() {
@Override
public void run() throws Exception {
next.dispose();
}
});
}
for (IWorkingSetElementAdapter next : elementAdapters.values()) {
SafeRunner.run(new WorkingSetRunnable() {
@Override
public void run() throws Exception {
next.dispose();
}
});
}
}
//---- working set creation -----------------------------------------------------
@Override
public IWorkingSet createWorkingSet(String name, IAdaptable[] elements) {
return new WorkingSet(name, name, elements);
}
@Override
public IWorkingSet createAggregateWorkingSet(String name, String label,
IWorkingSet[] components) {
return new AggregateWorkingSet(name, label, components);
}
@Override
public IWorkingSet createWorkingSet(IMemento memento) {
return restoreWorkingSet(memento);
}
//---- working set management ---------------------------------------------------
@Override
public void addWorkingSet(IWorkingSet workingSet) {
IWorkingSet wSet = getWorkingSet(workingSet.getName());
Assert.isTrue(wSet==null,"working set with same name already registered"); //$NON-NLS-1$
internalAddWorkingSet(workingSet);
}
private void internalAddWorkingSet(IWorkingSet workingSet) {
AbstractWorkingSet abstractWorkingSet = (AbstractWorkingSet) workingSet;
workingSets.add(abstractWorkingSet);
abstractWorkingSet.connect(this);
addToUpdater(workingSet);
firePropertyChange(CHANGE_WORKING_SET_ADD, null, workingSet);
}
protected boolean internalRemoveWorkingSet(IWorkingSet workingSet) {
boolean workingSetRemoved = workingSets.remove(workingSet);
boolean recentWorkingSetRemoved = recentWorkingSets.remove(workingSet);
if (workingSetRemoved) {
((AbstractWorkingSet)workingSet).disconnect();
removeFromUpdater(workingSet);
firePropertyChange(CHANGE_WORKING_SET_REMOVE, workingSet, null);
}
return workingSetRemoved || recentWorkingSetRemoved;
}
@Override
public IWorkingSet[] getWorkingSets() {
SortedSet<IWorkingSet> visibleSubset = new TreeSet<IWorkingSet>(WorkingSetComparator.getInstance());
for (IWorkingSet workingSet : workingSets) {
if (workingSet.isVisible()) {
visibleSubset.add(workingSet);
}
}
return visibleSubset.toArray(new IWorkingSet[visibleSubset.size()]);
}
@Override
public IWorkingSet[] getAllWorkingSets() {
IWorkingSet[] sets = workingSets.toArray(new IWorkingSet[workingSets.size()]);
Arrays.sort(sets, WorkingSetComparator.getInstance());
return sets;
}
@Override
public IWorkingSet getWorkingSet(String name) {
if (name == null || workingSets == null) {
return null;
}
for (IWorkingSet workingSet : workingSets) {
if (name.equals(workingSet.getName())) {
return workingSet;
}
}
return null;
}
// ---- recent working set management --------------------------------------
@Override
public IWorkingSet[] getRecentWorkingSets() {
return recentWorkingSets.toArray(new IWorkingSet[recentWorkingSets.size()]);
}
/**
* Adds the specified working set to the list of recently used
* working sets.
*
* @param workingSet working set to added to the list of recently
* used working sets.
*/
protected void internalAddRecentWorkingSet(IWorkingSet workingSet) {
if (!workingSet.isVisible()) {
return;
}
recentWorkingSets.remove(workingSet);
recentWorkingSets.add(0, workingSet);
sizeRecentWorkingSets();
}
//---- equals and hash code -----------------------------------------------
/**
* Tests the receiver and the object for equality
*
* @param object object to compare the receiver to
* @return true=the object equals the receiver, it has the same
* working sets. false otherwise
*/
@Override
public boolean equals(Object object) {
if (this == object) {
return true;
}
if (!getClass().getName().equals(object.getClass().getName())) {
return false;
}
AbstractWorkingSetManager other= (AbstractWorkingSetManager)object;
return other.workingSets.equals(workingSets);
}
/**
* Returns the hash code.
*
* @return the hash code.
*/
@Override
public int hashCode() {
return workingSets.hashCode();
}
//---- property listeners -------------------------------------------------
@Override
public void addPropertyChangeListener(IPropertyChangeListener listener) {
addListenerObject(listener);
}
@Override
public void removePropertyChangeListener(IPropertyChangeListener listener) {
removeListenerObject(listener);
}
/**
* Notify property change listeners about a change to the list of
* working sets.
*
* @param changeId one of
* IWorkingSetManager#CHANGE_WORKING_SET_ADD
* IWorkingSetManager#CHANGE_WORKING_SET_REMOVE
* IWorkingSetManager#CHANGE_WORKING_SET_CONTENT_CHANGE
* IWorkingSetManager#CHANGE_WORKING_SET_NAME_CHANGE
* @param oldValue the removed working set or null if a working set
* was added or changed.
* @param newValue the new or changed working set or null if a working
* set was removed.
*/
protected void firePropertyChange(String changeId, Object oldValue,
Object newValue) {
final Object[] listeners = getListeners();
if (listeners.length == 0) {
return;
}
final PropertyChangeEvent event = new PropertyChangeEvent(this,
changeId, oldValue, newValue);
Runnable notifier = () -> {
for (Object listener : listeners) {
final IPropertyChangeListener propertyChangeListener = (IPropertyChangeListener) listener;
ISafeRunnable safetyWrapper = new ISafeRunnable() {
@Override
public void run() throws Exception {
propertyChangeListener.propertyChange(event);
}
@Override
public void handleException(Throwable exception) {
// logged by the runner
}
};
SafeRunner.run(safetyWrapper);
}
};
// Notifications are sent on the UI thread.
if (Display.getCurrent() != null) {
notifier.run();
} else {
// Use an asyncExec to avoid deadlocks.
Display.getDefault().asyncExec(notifier);
}
}
/**
* Fires a property change event for the changed working set. Should only be
* called by org.eclipse.ui.internal.WorkingSet.
*
* @param changedWorkingSet
* the working set that has changed
* @param propertyChangeId
* the changed property. one of
* CHANGE_WORKING_SET_CONTENT_CHANGE,
* CHANGE_WORKING_SET_LABEL_CHANGE, and
* CHANGE_WORKING_SET_NAME_CHANGE
* @param oldValue
* the old value
*/
public void workingSetChanged(IWorkingSet changedWorkingSet,
String propertyChangeId, Object oldValue) {
firePropertyChange(propertyChangeId, oldValue, changedWorkingSet);
}
// ---- Persistence
// ----------------------------------------------------------------
/**
* Saves all persistable working sets in the persistence store.
*
* @param memento the persistence store
* @see IPersistableElement
*/
public void saveWorkingSetState(IMemento memento) {
Iterator<AbstractWorkingSet> iterator = workingSets.iterator();
// break the sets into aggregates and non aggregates. The aggregates should be saved after the non-aggregates
// so that on restoration all necessary aggregate components can be found.
ArrayList<IWorkingSet> standardSets = new ArrayList<>();
ArrayList<IWorkingSet> aggregateSets = new ArrayList<>();
while (iterator.hasNext()) {
IWorkingSet set = iterator.next();
if (set instanceof AggregateWorkingSet) {
aggregateSets.add(set);
} else {
standardSets.add(set);
}
}
saveWorkingSetState(memento, standardSets);
saveWorkingSetState(memento, aggregateSets);
}
/**
* @param memento the memento to save to
* @param list the working sets to save
* @since 3.2
*/
private void saveWorkingSetState(final IMemento memento, List list) {
for (Iterator i = list.iterator(); i.hasNext();) {
final IPersistableElement persistable = (IWorkingSet) i.next();
SafeRunner.run(new WorkingSetRunnable() {
@Override
public void run() throws Exception {
// create a dummy node to write too - the write could fail so we
// shouldn't soil the final memento until we're sure it succeeds.
XMLMemento dummy = XMLMemento.createWriteRoot(IWorkbenchConstants.TAG_WORKING_SET);
dummy.putString(IWorkbenchConstants.TAG_FACTORY_ID,
persistable.getFactoryId());
persistable.saveState(dummy);
// if the dummy was created successfully copy it to the real output
IMemento workingSetMemento = memento
.createChild(IWorkbenchConstants.TAG_WORKING_SET);
workingSetMemento.putMemento(dummy);
}
});
}
}
/**
* Recreates all working sets from the persistence store
* and adds them to the receiver.
*
* @param memento the persistence store
*/
protected void restoreWorkingSetState(IMemento memento) {
for (IMemento child : memento.getChildren(IWorkbenchConstants.TAG_WORKING_SET)) {
AbstractWorkingSet workingSet = (AbstractWorkingSet) restoreWorkingSet(child);
if (workingSet != null) {
internalAddWorkingSet(workingSet);
}
}
}
/**
* Recreates a working set from the persistence store.
*
* @param memento the persistence store
* @return the working set created from the memento or null if
* creation failed.
*/
protected IWorkingSet restoreWorkingSet(final IMemento memento) {
String factoryID = memento
.getString(IWorkbenchConstants.TAG_FACTORY_ID);
if (factoryID == null) {
// if the factory id was not set in the memento
// then assume that the memento was created using
// IMemento.saveState, and should be restored using WorkingSetFactory
factoryID = AbstractWorkingSet.FACTORY_ID;
}
final IElementFactory factory = PlatformUI.getWorkbench().getElementFactory(
factoryID);
if (factory == null) {
WorkbenchPlugin
.log("Unable to restore working set - cannot instantiate factory: " + factoryID); //$NON-NLS-1$
return null;
}
final IAdaptable[] adaptable = new IAdaptable[1];
SafeRunner.run(new WorkingSetRunnable() {
@Override
public void run() throws Exception {
adaptable[0] = factory.createElement(memento);
}
});
if (adaptable[0] == null) {
WorkbenchPlugin
.log("Unable to restore working set - cannot instantiate working set: " + factoryID); //$NON-NLS-1$
return null;
}
if ((adaptable[0] instanceof IWorkingSet) == false) {
WorkbenchPlugin
.log("Unable to restore working set - element is not an IWorkingSet: " + factoryID); //$NON-NLS-1$
return null;
}
return (IWorkingSet) adaptable[0];
}
/**
* Saves the list of most recently used working sets in the persistence
* store.
*
* @param memento the persistence store
*/
protected void saveMruList(IMemento memento) {
Iterator iterator = recentWorkingSets.iterator();
while (iterator.hasNext()) {
IWorkingSet workingSet = (IWorkingSet) iterator.next();
IMemento mruMemento = memento
.createChild(IWorkbenchConstants.TAG_MRU_LIST);
mruMemento.putString(IWorkbenchConstants.TAG_NAME, workingSet
.getName());
}
}
/**
* Restores the list of most recently used working sets from the
* persistence store.
*
* @param memento the persistence store
*/
protected void restoreMruList(IMemento memento) {
IMemento[] mruWorkingSets = memento
.getChildren(IWorkbenchConstants.TAG_MRU_LIST);
for (int i = mruWorkingSets.length - 1; i >= 0; i--) {
String workingSetName = mruWorkingSets[i]
.getString(IWorkbenchConstants.TAG_NAME);
if (workingSetName != null) {
IWorkingSet workingSet = getWorkingSet(workingSetName);
if (workingSet != null) {
internalAddRecentWorkingSet(workingSet);
}
}
}
}
//---- user interface support -----------------------------------------------------
/**
* @see org.eclipse.ui.IWorkingSetManager#createWorkingSetEditWizard(org.eclipse.ui.IWorkingSet)
* @since 2.1
*/
@Override
public IWorkingSetEditWizard createWorkingSetEditWizard(
IWorkingSet workingSet) {
String editPageId = workingSet.getId();
WorkingSetRegistry registry = WorkbenchPlugin.getDefault()
.getWorkingSetRegistry();
IWorkingSetPage editPage = null;
if (editPageId != null) {
editPage = registry.getWorkingSetPage(editPageId);
}
// the following block kind of defeats IWorkingSet.isEditable() and it
// doesn't make sense for there to be a default page in such a case.
if (editPage == null) {
editPage = registry.getDefaultWorkingSetPage();
if (editPage == null) {
return null;
}
}
WorkingSetEditWizard editWizard = new WorkingSetEditWizard(editPage);
editWizard.setSelection(workingSet);
return editWizard;
}
/**
* @deprecated use createWorkingSetSelectionDialog(parent, true) instead
*/
@Deprecated
@Override
public IWorkingSetSelectionDialog createWorkingSetSelectionDialog(
Shell parent) {
return createWorkingSetSelectionDialog(parent, true);
}
@Override
public IWorkingSetSelectionDialog createWorkingSetSelectionDialog(
Shell parent, boolean multi) {
return createWorkingSetSelectionDialog(parent, multi, null);
}
/**
* {@inheritDoc}
*/
@Override
public IWorkingSetNewWizard createWorkingSetNewWizard(String[] workingSetIds) {
WorkingSetDescriptor[] descriptors= getSupportedEditableDescriptors(workingSetIds);
if (descriptors.length == 0) {
return null;
}
return new WorkingSetNewWizard(descriptors);
}
//---- working set delta handling -------------------------------------------------
@Override
public void bundleChanged(BundleEvent event) {
String symbolicName = event.getBundle().getSymbolicName();
if (symbolicName == null)
return;
// If the workbench isn't running anymore simply return.
if (!PlatformUI.isWorkbenchRunning()) {
return;
}
if (event.getBundle().getState() == Bundle.ACTIVE) {
final WorkingSetDescriptor[] descriptors = WorkbenchPlugin.getDefault()
.getWorkingSetRegistry().getUpdaterDescriptorsForNamespace(
symbolicName);
Job job = new WorkbenchJob(
NLS
.bind(
WorkbenchMessages.AbstractWorkingSetManager_updatersActivating,
symbolicName)) {
@Override
public IStatus runInUIThread(IProgressMonitor monitor) {
synchronized (updaters) {
for (WorkingSetDescriptor descriptor : descriptors) {
List workingSets = getWorkingSetsForId(descriptor
.getId());
if (workingSets.size() == 0) {
continue;
}
final IWorkingSetUpdater updater = getUpdater(descriptor);
for (Iterator iter = workingSets.iterator(); iter
.hasNext();) {
final IWorkingSet workingSet = (IWorkingSet) iter
.next();
SafeRunner.run(new WorkingSetRunnable() {
@Override
public void run() throws Exception {
if (!updater.contains(workingSet)) {
updater.add(workingSet);
}
}
});
}
}
}
return Status.OK_STATUS;
}
};
job.setSystem(true);
job.schedule();
}
}
private List getWorkingSetsForId(String id) {
List result= new ArrayList();
for (IWorkingSet ws : workingSets) {
if (id.equals(ws.getId())) {
result.add(ws);
}
}
return result;
}
private void addToUpdater(final IWorkingSet workingSet) {
WorkingSetDescriptor descriptor= WorkbenchPlugin.getDefault()
.getWorkingSetRegistry().getWorkingSetDescriptor(workingSet.getId());
if (descriptor == null || !descriptor.isUpdaterClassLoaded()) {
return;
}
synchronized(updaters) {
final IWorkingSetUpdater updater= getUpdater(descriptor);
SafeRunner.run(new WorkingSetRunnable() {
@Override
public void run() throws Exception {
if (!updater.contains(workingSet)) {
updater.add(workingSet);
}
}});
}
}
private IWorkingSetUpdater getUpdater(WorkingSetDescriptor descriptor) {
IWorkingSetUpdater updater = updaters.get(descriptor.getId());
if (updater == null) {
updater = descriptor.createWorkingSetUpdater();
if (updater == null) {
updater = NULL_UPDATER;
} else {
firePropertyChange(CHANGE_WORKING_SET_UPDATER_INSTALLED, null, updater);
PlatformUI.getWorkbench().getExtensionTracker().registerObject(
descriptor.getConfigurationElement().getDeclaringExtension(), updater,
IExtensionTracker.REF_WEAK);
}
updaters.put(descriptor.getId(), updater);
}
return updater;
}
IWorkingSetElementAdapter getElementAdapter(WorkingSetDescriptor descriptor) {
IWorkingSetElementAdapter elementAdapter = elementAdapters.get(descriptor.getId());
if (elementAdapter == null) {
elementAdapter = descriptor.createWorkingSetElementAdapter();
if (elementAdapter == null) {
elementAdapter = IDENTITY_ADAPTER;
} else {
elementAdapters.put(descriptor.getId(), elementAdapter);
}
}
return elementAdapter;
}
private void removeFromUpdater(final IWorkingSet workingSet) {
synchronized (updaters) {
final IWorkingSetUpdater updater = updaters.get(workingSet.getId());
if (updater != null) {
SafeRunner.run(new WorkingSetRunnable() {
@Override
public void run() throws Exception {
updater.remove(workingSet);
}
});
}
}
}
@Override
public IWorkingSetSelectionDialog createWorkingSetSelectionDialog(Shell parent, boolean multi, String[] workingsSetIds) {
return new WorkingSetSelectionDialog(parent, multi, workingsSetIds);
}
/**
* Save the state to the state file.
*
* @param stateFile
* @throws IOException
*/
public void saveState(File stateFile) throws IOException {
XMLMemento memento = XMLMemento
.createWriteRoot(IWorkbenchConstants.TAG_WORKING_SET_MANAGER);
saveWorkingSetState(memento);
saveMruList(memento);
FileOutputStream stream = new FileOutputStream(stateFile);
OutputStreamWriter writer = new OutputStreamWriter(stream, StandardCharsets.UTF_8);
memento.save(writer);
writer.close();
}
@Override
public void addExtension(IExtensionTracker tracker, IExtension extension) {
// nothing - this is handled lazily. These items are only created as needed by the getUpdater() and getElementAdapter() methods
}
@Override
public void removeExtension(IExtension extension, Object[] objects) {
for (Object object : objects) {
if (object instanceof IWorkingSetUpdater) {
removeUpdater((IWorkingSetUpdater)object);
}
if (object instanceof IWorkingSetElementAdapter) {
removeElementAdapter((IWorkingSetElementAdapter) object);
}
}
}
/**
* Remove the element adapter from the manager and dispose of it.
*
* @param elementAdapter
* @since 3.3
*/
private void removeElementAdapter(
final IWorkingSetElementAdapter elementAdapter) {
SafeRunner.run(new WorkingSetRunnable() {
@Override
public void run() throws Exception {
elementAdapter.dispose();
}
});
synchronized (elementAdapters) {
elementAdapters.values().remove(elementAdapter);
}
}
/**
* Remove the updater from the manager and dispose of it.
*
* @param updater
* @since 3.3
*/
private void removeUpdater(final IWorkingSetUpdater updater) {
SafeRunner.run(new WorkingSetRunnable() {
@Override
public void run() throws Exception {
updater.dispose();
}
});
synchronized (updaters) {
updaters.values().remove(updater);
}
firePropertyChange(IWorkingSetManager.CHANGE_WORKING_SET_UPDATER_UNINSTALLED, updater, null);
}
@Override
public void addToWorkingSets(final IAdaptable element, IWorkingSet[] workingSets) {
// ideally this method would be in a static util class of some kind but
// we dont have any such beast for working sets and making one for one
// method is overkill.
for (final IWorkingSet workingSet : workingSets) {
SafeRunner.run(new WorkingSetRunnable() {
@Override
public void run() throws Exception {
IAdaptable[] adaptedNewElements = workingSet
.adaptElements(new IAdaptable[] { element });
if (adaptedNewElements.length == 1) {
IAdaptable[] elements = workingSet.getElements();
IAdaptable[] newElements = new IAdaptable[elements.length + 1];
System.arraycopy(elements, 0, newElements, 0,
elements.length);
newElements[newElements.length - 1] = adaptedNewElements[0];
workingSet.setElements(newElements);
}
}});
}
}
@Override
public void setRecentWorkingSetsLength(int length) {
if (length < 1 || length > 99)
throw new IllegalArgumentException("Invalid recent working sets length: " + length); //$NON-NLS-1$
IPreferenceStore store = PrefUtil.getAPIPreferenceStore();
store.setValue(IWorkbenchPreferenceConstants.RECENTLY_USED_WORKINGSETS_SIZE, length);
// adjust length
sizeRecentWorkingSets();
}
private void sizeRecentWorkingSets() {
int maxLength = getRecentWorkingSetsLength();
while (recentWorkingSets.size() > maxLength) {
int lastPosition = recentWorkingSets.size() - 1;
recentWorkingSets.remove(lastPosition);
}
}
@Override
public int getRecentWorkingSetsLength() {
IPreferenceStore store = PrefUtil.getAPIPreferenceStore();
return store.getInt(IWorkbenchPreferenceConstants.RECENTLY_USED_WORKINGSETS_SIZE);
}
}